{
 "nbformat": 4,
 "nbformat_minor": 0,
 "metadata": {
  "colab": {
   "name": "DeepONet_antideriv.ipynb",
   "provenance": [],
   "collapsed_sections": []
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3"
  },
  "accelerator": "GPU"
 },
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "id": "mRR_BT5vUnSw"
   },
   "source": [
    "import numpy as onp\n",
    "import jax.numpy as np\n",
    "from jax import random, grad, vmap, jit\n",
    "from jax.example_libraries import optimizers\n",
    "from jax.experimental.ode import odeint\n",
    "from jax.nn import relu\n",
    "from jax.config import config\n",
    "\n",
    "import itertools\n",
    "from functools import partial\n",
    "from torch.utils import data\n",
    "from tqdm import trange\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline"
   ],
   "execution_count": 1,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "rTZSJ2taqCPZ"
   },
   "source": [
    "# Define the neural net\n",
    "def MLP(layers, activation=relu):\n",
    "  ''' Vanilla MLP'''\n",
    "  def init(rng_key):\n",
    "      def init_layer(key, d_in, d_out):\n",
    "          k1, k2 = random.split(key)\n",
    "          glorot_stddev = 1. / np.sqrt((d_in + d_out) / 2.)\n",
    "          W = glorot_stddev * random.normal(k1, (d_in, d_out))\n",
    "          b = np.zeros(d_out)\n",
    "          return W, b\n",
    "      key, *keys = random.split(rng_key, len(layers))\n",
    "      params = list(map(init_layer, keys, layers[:-1], layers[1:]))\n",
    "      return params\n",
    "  def apply(params, inputs):\n",
    "      for W, b in params[:-1]:\n",
    "          outputs = np.dot(inputs, W) + b\n",
    "          inputs = activation(outputs)\n",
    "      W, b = params[-1]\n",
    "      outputs = np.dot(inputs, W) + b\n",
    "      return outputs\n",
    "  return init, apply"
   ],
   "execution_count": 2,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "yPdIBu2xPoi4"
   },
   "source": [
    "# Data generator\n",
    "class DataGenerator(data.Dataset):\n",
    "    def __init__(self, u, y, s, \n",
    "                 batch_size=64, rng_key=random.PRNGKey(1234)):\n",
    "        'Initialization'\n",
    "        self.u = u # input sample\n",
    "        self.y = y # location\n",
    "        self.s = s # labeled data evulated at y (solution measurements, BC/IC conditions, etc.)\n",
    "        \n",
    "        self.N = u.shape[0]\n",
    "        self.batch_size = batch_size\n",
    "        self.key = rng_key\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        'Generate one batch of data'\n",
    "        self.key, subkey = random.split(self.key)\n",
    "        inputs, outputs = self.__data_generation(subkey)\n",
    "        return inputs, outputs\n",
    "\n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def __data_generation(self, key):\n",
    "        'Generates data containing batch_size samples'\n",
    "        idx = random.choice(key, self.N, (self.batch_size,), replace=False)\n",
    "        s = self.s[idx,:]\n",
    "        y = self.y[idx,:]\n",
    "        u = self.u[idx,:]\n",
    "        # Construct batch\n",
    "        inputs = (u, y)\n",
    "        outputs = s\n",
    "        return inputs, outputs"
   ],
   "execution_count": 3,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "kbh_Vdc8VmZZ"
   },
   "source": [
    "# Define the model\n",
    "class DeepONet:\n",
    "    def __init__(self, branch_layers, trunk_layers):    \n",
    "        # Network initialization and evaluation functions\n",
    "        self.branch_init, self.branch_apply = MLP(branch_layers, activation=relu)\n",
    "        self.trunk_init, self.trunk_apply = MLP(trunk_layers, activation=relu)\n",
    "\n",
    "        # Initialize\n",
    "        branch_params = self.branch_init(rng_key = random.PRNGKey(1234))\n",
    "        trunk_params = self.trunk_init(rng_key = random.PRNGKey(4321))\n",
    "        params = (branch_params, trunk_params)\n",
    "\n",
    "        # Use optimizers to set optimizer initialization and update functions\n",
    "        self.opt_init, \\\n",
    "        self.opt_update, \\\n",
    "        self.get_params = optimizers.adam(optimizers.exponential_decay(1e-3, \n",
    "                                                                      decay_steps=1000, \n",
    "                                                                      decay_rate=0.9))\n",
    "        self.opt_state = self.opt_init(params)\n",
    "\n",
    "        self.itercount = itertools.count()\n",
    "        # Logger\n",
    "        self.loss_log = []\n",
    "\n",
    "    # Define opeartor net\n",
    "    def operator_net(self, params, u, y):\n",
    "        branch_params, trunk_params = params\n",
    "        B = self.branch_apply(branch_params, u)\n",
    "        T = self.trunk_apply(trunk_params, y)\n",
    "        outputs = np.sum(B * T)\n",
    "        return outputs\n",
    "      \n",
    "    # Define ODE/PDE residual\n",
    "    def residual_net(self, params, u, y):\n",
    "        s_y = grad(self.operator_net, argnums = 2)(params, u, y)\n",
    "        return s_y\n",
    "\n",
    "    # Define loss\n",
    "    def loss(self, params, batch):\n",
    "        # Fetch data\n",
    "        # inputs: (u, y), shape = (N, m), (N,1)\n",
    "        # outputs: s, shape = (N,1)\n",
    "        inputs, outputs = batch\n",
    "        u, y = inputs\n",
    "        # Compute forward pass\n",
    "        pred = vmap(self.operator_net, (None, 0, 0))(params, u, y)\n",
    "        # Compute loss\n",
    "        loss = np.mean((outputs.flatten() - pred)**2)\n",
    "        return loss\n",
    "\n",
    "    # Define a compiled update step\n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def step(self, i, opt_state, batch):\n",
    "        params = self.get_params(opt_state)\n",
    "        g = grad(self.loss)(params, batch)\n",
    "        return self.opt_update(i, g, opt_state)\n",
    "\n",
    "    # Optimize parameters in a loop\n",
    "    def train(self, dataset, nIter = 10000):\n",
    "        data = iter(dataset)\n",
    "        pbar = trange(nIter)\n",
    "        # Main training loop\n",
    "        for it in pbar:\n",
    "            batch = next(data)\n",
    "            self.opt_state = self.step(next(self.itercount), self.opt_state, batch)\n",
    "            \n",
    "            if it % 100 == 0:\n",
    "                params = self.get_params(self.opt_state)\n",
    "\n",
    "                # Compute loss\n",
    "                loss_value = self.loss(params, batch)\n",
    "\n",
    "                # Store loss\n",
    "                self.loss_log.append(loss_value)\n",
    "\n",
    "                # Print loss during training\n",
    "                pbar.set_postfix({'Loss': loss_value})\n",
    "       \n",
    "    # Evaluates predictions at test points  \n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def predict_s(self, params, U_star, Y_star):\n",
    "        s_pred = vmap(self.operator_net, (None, 0, 0))(params, U_star, Y_star)\n",
    "        return s_pred\n",
    "\n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def predict_s_y(self, params, U_star, Y_star):\n",
    "        s_y_pred = vmap(self.residual_net, (None, 0, 0))(params, U_star, Y_star)\n",
    "        return s_y_pred"
   ],
   "execution_count": 4,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "k6NL6NI7P9Jo"
   },
   "source": [
    "# Length scale of a Gaussian random field (GRF)\n",
    "length_scale = 0.2\n",
    "\n",
    "# Define RBF kernel\n",
    "def RBF(x1, x2, params):\n",
    "    output_scale, lengthscales = params\n",
    "    diffs = np.expand_dims(x1 / lengthscales, 1) - \\\n",
    "            np.expand_dims(x2 / lengthscales, 0)\n",
    "    r2 = np.sum(diffs**2, axis=2)\n",
    "    return output_scale * np.exp(-0.5 * r2)\n",
    "\n",
    "# Geneate training data corresponding to one input sample\n",
    "def generate_one_training_data(key, m=100, P=1):\n",
    "    # Sample GP prior at a fine grid\n",
    "    N = 512\n",
    "    gp_params = (1.0, length_scale)\n",
    "    jitter = 1e-10\n",
    "    X = np.linspace(0, 1, N)[:,None]\n",
    "    K = RBF(X, X, gp_params)\n",
    "    L = np.linalg.cholesky(K + jitter*np.eye(N))\n",
    "    gp_sample = np.dot(L, random.normal(key, (N,)))\n",
    "\n",
    "    # Create a callable interpolation function  \n",
    "    u_fn = lambda x, t: np.interp(t, X.flatten(), gp_sample)\n",
    "\n",
    "    # Input sensor locations and measurements\n",
    "    x = np.linspace(0, 1, m)\n",
    "    u = vmap(u_fn, in_axes=(None,0))(0.0, x)\n",
    "\n",
    "    # Output sensor locations and measurements\n",
    "    y_train = random.uniform(key, (P,)).sort() \n",
    "    s_train = odeint(u_fn, 0.0, np.hstack((0.0, y_train)))[1:] # JAX has a bug and always returns s(0), so add a dummy entry to y and return s[1:]\n",
    "\n",
    "    # Tile inputs\n",
    "    u_train = np.tile(u, (P,1))\n",
    "\n",
    "    # training data for the residual\n",
    "    u_r_train = np.tile(u, (m, 1))\n",
    "    y_r_train = x\n",
    "    s_r_train = u\n",
    "\n",
    "    return u_train, y_train, s_train, u_r_train, y_r_train,  s_r_train\n",
    "\n",
    "# Geneate test data corresponding to one input sample\n",
    "def generate_one_test_data(key, m=100, P=100):\n",
    "    # Sample GP prior at a fine grid\n",
    "    N = 512\n",
    "    gp_params = (1.0, length_scale)\n",
    "    jitter = 1e-10\n",
    "    X = np.linspace(0, 1, N)[:,None]\n",
    "    K = RBF(X, X, gp_params)\n",
    "    L = np.linalg.cholesky(K + jitter*np.eye(N))\n",
    "    gp_sample = np.dot(L, random.normal(key, (N,)))\n",
    "\n",
    "    # Create a callable interpolation function  \n",
    "    u_fn = lambda x, t: np.interp(t, X.flatten(), gp_sample)\n",
    "\n",
    "    # Input sensor locations and measurements\n",
    "    x = np.linspace(0, 1, m)\n",
    "    u = vmap(u_fn, in_axes=(None,0))(0.0, x)\n",
    "\n",
    "    # Output sensor locations and measurements\n",
    "    y = np.linspace(0, 1, P)\n",
    "    s = odeint(u_fn, 0.0, y)\n",
    "\n",
    "    # Tile inputs\n",
    "    u = np.tile(u, (P,1))\n",
    "\n",
    "    return u, y, s \n",
    "\n",
    "# Geneate training data corresponding to N input sample\n",
    "def generate_training_data(key, N, m, P):\n",
    "    config.update(\"jax_enable_x64\", True)\n",
    "    keys = random.split(key, N)\n",
    "    gen_fn = jit(lambda key: generate_one_training_data(key, m, P))\n",
    "    u_train, y_train, s_train, u_r_train, y_r_train, s_r_train = vmap(gen_fn)(keys)\n",
    "\n",
    "    u_train = np.float32(u_train.reshape(N * P,-1))\n",
    "    y_train = np.float32(y_train.reshape(N * P,-1))\n",
    "    s_train = np.float32(s_train.reshape(N * P,-1))\n",
    "\n",
    "    u_r_train = np.float32(u_r_train.reshape(N * m,-1))\n",
    "    y_r_train = np.float32(y_r_train.reshape(N * m,-1))\n",
    "    s_r_train = np.float32(s_r_train.reshape(N * m,-1))\n",
    "\n",
    "    config.update(\"jax_enable_x64\", False)\n",
    "    return u_train, y_train, s_train, u_r_train, y_r_train,  s_r_train\n",
    "\n",
    "# Geneate test data corresponding to N input sample\n",
    "def generate_test_data(key, N, m, P):\n",
    "    config.update(\"jax_enable_x64\", True)\n",
    "    keys = random.split(key, N)\n",
    "    gen_fn = jit(lambda key: generate_one_test_data(key, m, P))\n",
    "    u, y, s = vmap(gen_fn)(keys)\n",
    "    u = np.float32(u.reshape(N * P,-1))\n",
    "    y = np.float32(y.reshape(N * P,-1))\n",
    "    s = np.float32(s.reshape(N * P,-1))\n",
    "\n",
    "    config.update(\"jax_enable_x64\", False)\n",
    "    return u, y, s\n",
    "\n",
    "# Compute relative l2 error over N test samples.\n",
    "def compute_error(key, m, P):\n",
    "    # Generate one test sample\n",
    "    u_test, y_test, s_test = generate_test_data(key, 1, m, P)\n",
    "    \n",
    "    # Predict the solution and the residual\n",
    "    s_pred = model.predict_s(params, u_test, y_test)[:,None]\n",
    "    s_y_pred = model.predict_s_y(params, u_test, y_test)\n",
    "\n",
    "    # Compute relative l2 error\n",
    "    error_s = np.linalg.norm(s_test - s_pred) / np.linalg.norm(s_test) \n",
    "    error_u = np.linalg.norm(u_test[::P_test].flatten()[:,None] - s_y_pred) / np.linalg.norm(u_test[::P_test].flatten()[:,None]) \n",
    "\n",
    "    return error_s, error_u\n"
   ],
   "execution_count": 5,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "ZQ-HVgaQt0DO"
   },
   "source": [
    "# Training data for  operator loss\n",
    "N_train = 10000\n",
    "m = 100 # number of input sensors\n",
    "P_train = 1   # number of output sensors\n",
    "key_train = random.PRNGKey(0)  # use different key for generating training data and test data \n",
    "u_train, y_train, s_train, _, _, _ = generate_training_data(key_train, N_train, m, P_train)\n",
    "\n",
    "# If solve the forward problem\n",
    "# y_train = np.zeros((N_train, 1))\n",
    "# s_train = np.zeros((N_train, 1))"
   ],
   "execution_count": 6,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "3e0d9ay6he_Q"
   },
   "source": [
    "# Initialize model\n",
    "# For vanilla DeepONet, shallower network yields better accuarcy.\n",
    "branch_layers = [100, 100, 100] \n",
    "trunk_layers =  [1, 100, 100]\n",
    "\n",
    "# branch_layers = [m, 50, 50, 50, 50, 50]\n",
    "# trunk_layers =  [1,  50, 50, 50, 50, 50]\n",
    "\n",
    "model = DeepONet(branch_layers, trunk_layers)"
   ],
   "execution_count": 7,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "BmduhGwcHHXs"
   },
   "source": [
    "# Create data set\n",
    "batch_size = 10000\n",
    "dataset = DataGenerator(u_train, y_train, s_train, batch_size)"
   ],
   "execution_count": 8,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "gW8Ej5Jvhf0r",
    "outputId": "1e9b918d-c86b-40bb-9c9b-0c6950cb30fa"
   },
   "source": [
    "# Train\n",
    "model.train(dataset, nIter=40000)"
   ],
   "execution_count": 9,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "100%|██████████| 40000/40000 [01:18<00:00, 510.73it/s, Loss=7.7451557e-07]\n"
     ],
     "name": "stderr"
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "hFf9NGzBiDS5",
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "outputId": "6e46be94-2e0f-48a0-d35a-43b0a6cac795"
   },
   "source": [
    "# Compute test error\n",
    "N_test = 1000 # number of input samples \n",
    "P_test = m   # number of sensors \n",
    "key_test = random.PRNGKey(12345) # A different key \n",
    "keys_test = random.split(key_test, N_test)\n",
    "\n",
    "# Predict\n",
    "params = model.get_params(model.opt_state)\n",
    "\n",
    "# Compute errors over test dataset\n",
    "error_s, error_u = vmap(compute_error, (0, None, None))(keys_test, m, P_test) \n",
    "\n",
    "print('mean of relative L2 error of s: {:.2e}'.format(error_s.mean()))\n",
    "print('mean of relative L2 error of u: {:.2e}'.format(error_u.mean()))\n",
    "\n",
    "print('std of relative L2 error of s: {:.2e}'.format(error_s.std()))\n",
    "print('std L2 error of u: {:.2e}'.format(error_u.std()))"
   ],
   "execution_count": 14,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "mean of relative L2 error of s: 5.01e-03\n",
      "mean of relative L2 error of u: 1.41e-01\n",
      "std of relative L2 error of s: 4.47e-03\n",
      "std L2 error of u: 5.63e-02\n"
     ],
     "name": "stdout"
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 369
    },
    "id": "uhMrQopGN__b",
    "outputId": "55c5326b-10c9-47cd-9705-e281fb04534c"
   },
   "source": [
    "#Plot for loss function\n",
    "loss = np.array(model.loss_log)\n",
    "\n",
    "plt.figure(figsize = (6,5))\n",
    "plt.plot(loss, lw=2)\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Loss')\n",
    "plt.yscale('log')\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ],
   "execution_count": 15,
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": [],
      "needs_background": "light"
     }
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "PUs0V2kAGDSb"
   },
   "source": [
    "# Generate test data\n",
    "N_test = 100\n",
    "P_test = m\n",
    "key_test = random.PRNGKey(12345)\n",
    "keys_test = random.split(key_test, N_test)\n",
    "\n",
    "u_test, y_test, s_test =  generate_test_data(key_test, N_test, m, m)\n",
    "\n",
    "params = model.get_params(model.opt_state)\n",
    "\n",
    "# Model predictions\n",
    "s_pred = model.predict_s(params, u_test, y_test)[:,None]\n",
    "s_y_pred = model.predict_s_y(params, u_test, y_test)"
   ],
   "execution_count": 16,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 754
    },
    "id": "NicghBbsmLUH",
    "outputId": "b3bd94be-58d1-4e03-d937-d21e1e131627"
   },
   "source": [
    "# Plot for one generated data\n",
    "# idx = onp.random.randint(N_test) # random visualizations\n",
    "idx=0\n",
    "index = np.arange(idx * P_test,(idx + 1) * P_test)\n",
    "\n",
    "# Compute the relative l2 error for one input sample \n",
    "error_u = np.linalg.norm(s_test[index, :] - s_pred[index, :], 2) / np.linalg.norm(s_test[index, :], 2) \n",
    "error_s = np.linalg.norm(u_test[::P_test][idx].flatten()[:,None] - s_y_pred[index, :], 2) / np.linalg.norm(u_test[::P_test][idx].flatten()[:,None], 2) \n",
    "\n",
    "print(\"error_u: {:.3e}\".format(error_u))\n",
    "print(\"error_s: {:.3e}\".format(error_s))\n",
    "\n",
    "# Visualizations\n",
    "# Predicted solution s(y)\n",
    "plt.figure(figsize=(12,5))\n",
    "plt.subplot(1,2,1)\n",
    "plt.plot(y_test[index, :], s_test[index, :], label='Exact s', lw=2)\n",
    "plt.plot(y_test[index, :], s_pred[index, :], '--', label='Predicted s', lw=2)\n",
    "plt.xlabel('y')\n",
    "plt.ylabel('s(y)')\n",
    "plt.tight_layout()\n",
    "plt.legend()\n",
    "\n",
    "plt.subplot(1,2,2)\n",
    "plt.plot(y_test[index, :], s_pred[index, :] - s_test[index, :], '--', lw=2, label='error')\n",
    "plt.tight_layout()\n",
    "plt.legend()\n",
    "plt.show()\n",
    "\n",
    "# Predicted residual u(x)\n",
    "fig = plt.figure(figsize=(12,5))\n",
    "plt.subplot(1,2,1)\n",
    "plt.plot(y_test[index, :], u_test[::P_test][idx], label='Exact u', lw=2)\n",
    "plt.plot(y_test[index, :], s_y_pred[index,:], '--', label='Predicted u', lw=2)\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.subplot(1,2,2)\n",
    "plt.plot(y_test[index, :], s_y_pred[index,:].flatten() - u_test[::P_test][idx] , '--', label='error', lw=2)\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ],
   "execution_count": 17,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "error_u: 5.208e-03\n",
      "error_s: 1.131e-01\n"
     ],
     "name": "stdout"
    },
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "tags": [],
      "needs_background": "light"
     }
    },
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "tags": [],
      "needs_background": "light"
     }
    }
   ]
  }
 ]
}
